local db = TUNING.MOD_MOD_PONO.badge.mod_pono_energy

AddPrefabPostInit("pono", function(inst)
    if not TheWorld.ismastersim then
        return inst
    end
    -- 添加组件（服务器端）
    inst:AddComponent("mod_pono_energy")
    
    -- 【关键】添加 sleeper 组件，用于强制睡眠功能
    if not inst.components.sleeper then
        inst:AddComponent("sleeper")
        -- 【修复】禁用sleeper组件的自动睡眠判断，避免在晚上误触发
        -- 我们只使用sleeper组件的强制睡眠功能，不使用其自动睡眠检测
        inst.components.sleeper.sleepiness = 0
        inst.components.sleeper.sleepiness_rate = 0
    end

    -- 初始化能量：仅当当前值为 0（新玩家/未保存值）时设置为 tuning.init，避免覆盖已有存档值。
    if inst.components.mod_pono_energy then
        local function InitIfEmpty()
            local energy_comp = inst.components.mod_pono_energy
            if energy_comp then
                local curval = energy_comp:GetVal() or 0
                -- 仅在没有保存值（==0）时应用初始值
                if curval == 0 and (db.init or 0) > 0 then
                    energy_comp:SetVal(db.init)
                end
            end
        end

        -- 当组件完成加载时触发（component OnLoad 会 PushEvent），优先使用该事件来初始化
        inst:ListenForEvent("mod_pono_energy_onload", function(inst, data)
            InitIfEmpty()
        end)

        -- 作为后备，延迟执行一次初始化（如果事件未触发）
        inst:DoTaskInTime(0.5, function()
            InitIfEmpty()
        end)
    end


    -- 能量系统加成/惩罚管理
    -- 加成范围：能量值在 25-175 时生效
    -- 1. 工作效率加成（动画加速×2 + workmultiplier）
    -- 2. 攻击力加成：+10%（在 dmg_sys.lua 中实现）
    -- 3. 移速加成：+10%（SetExternalSpeedMultiplier）
    -- 4. 攻击速度加成：攻击间隔×0.05（在 modmain.lua 的 combat hook 中实现）
    --
    -- 惩罚范围：能量值在 0-25 时生效
    -- 1. 攻击力惩罚：-20%（在 dmg_sys.lua 中实现）
    -- 2. 移速惩罚：-5%（SetExternalSpeedMultiplier）
    --
    -- 催眠状态：能量值 > 175 时生效
    -- 1. 进入催眠减速状态（类似食用曼德拉草后的groggy状态）
    -- 2. 移速大幅降低
    -- 3. 每秒回复2点理智和2点血量
    --
    -- 暗影伤害：受到暗影生物攻击时
    -- 1. 扣除10点能量值
    -- 2. 扣除与伤害等量的理智值
    --
    -- 能量消耗加速：基础消耗×加速倍数（加算）
    -- 1. 理智低于最大值一半：消耗+1倍
    -- 2. 生命值低于最大值一半：消耗+1倍  
    -- 3. 潮湿度高于50：消耗+1倍
    -- 4. 同时满足时：消耗×6倍（1+1+1+1+1+1=6倍）
    local work_multiplier_key = "mod_pono_energy_boost"
    local speed_multiplier_key = "mod_pono_energy_speed_boost"
    local speed_penalty_key = "mod_pono_energy_speed_penalty"
    local groggy_speed_key = "mod_pono_energy_groggy"
    local speed_mode_key = "mod_pono_speed_mode"  -- 快速移动模式
    local PICK_MULT = 1.5    -- 采集加速倍率（配合动画×2加速）
    local CHOP_MULT = 1.7    -- 砍伐加速倍率
    local MINE_MULT = 1.7    -- 开采加速倍率
    local DIG_MULT = 1.7     -- 挖掘加速倍率
    local SPEED_MULT = 1.1   -- 移速加成倍率：+10%
    local SPEED_PENALTY = 0.95  -- 移速惧罚倍率：-5%
    local GROGGY_SPEED = 0.5    -- 催眠减速倍率：50% (类似曼德拉草效果)
    local SPEED_MODE_MULT = 2.2  -- 快速移动模式：+120%
    
    -- 在实例上存储状态，避免模块级别缓存
    inst._pono_has_work_boost = false

    -- 【新功能】计算能量消耗加速倍数的通用函数
    local function GetEnergyConsumeMultiplier(inst)
        local consume_multiplier = 1
        
        -- 【新功能】启蒙区域判断：角色位于启蒙区域时，能量消耗降低为1/6
        -- 启蒙区域包括：
        -- 1. 月亮风暴开启时，每天夜晚整个森林世界
        -- 2. 月亮裂隙循环开启后，满月时整个森林世界
        -- 3. 月亮风暴区域内
        -- 4. 月亮沼泽地块或月亮裂隙地块
        -- 5. 月岛、月亮洞窟群系
        
        local is_in_enlightenment_area = false
        
        -- 获取角色当前位置
        local x, y, z = inst.Transform:GetWorldPosition()
        
        if TheWorld then
            -- 方法1：检查世界状态 - 是否处于全球启蒙时间
            -- 月亮风暴夜晚 或 满月（裂隙循环开启）
            if TheWorld.state then
                local is_night = TheWorld.state.isnight
                local is_full_moon = TheWorld.state.isfullmoon
                
                -- 检查月亮风暴
                local has_moon_storm = false
                if TheWorld.components.moonstorms then
                    -- 尝试不同的方法检查月亮风暴
                    if TheWorld.components.moonstorms.IsActiveMoonstorm then
                        has_moon_storm = TheWorld.components.moonstorms:IsActiveMoonstorm()
                    elseif TheWorld.components.moonstorms.moonstorms then
                        -- 检查是否有活跃的风暴
                        has_moon_storm = next(TheWorld.components.moonstorms.moonstorms) ~= nil
                    end
                end
                
                -- 月亮风暴开启且是夜晚
                if has_moon_storm and is_night then
                    is_in_enlightenment_area = true
                    print("[PonoEnergy] In enlightenment area: Moon storm night!")
                end
                
                -- 满月时（如果月亮裂隙循环已开启）
                if not is_in_enlightenment_area and is_full_moon then
                    -- 检查是否有月亮裂隙系统
                    if TheWorld.components.lunarthrall_plantspawner or 
                       TheWorld.components.riftspawner or
                       TheWorld.components.lunarriftmutationsmanager then
                        is_in_enlightenment_area = true
                        print("[PonoEnergy] In enlightenment area: Full moon with rift system!")
                    end
                end
            end
            
            -- 方法2：检查是否在局部启蒙区域（月岛、月亮地块等）
            if not is_in_enlightenment_area and TheWorld.Map then
                -- 检查地面tile类型
                local tile = TheWorld.Map:GetTileAtPoint(x, y, z)
                
                -- 月岛相关地形
                if tile == GROUND.METEOR or 
                   tile == GROUND.FUNGUS_MOON or 
                   tile == GROUND.MOON_ISLAND or
                   tile == GROUND.ARCHIVE or
                   tile == GROUND.PEBBLEBEACH or
                   tile == GROUND.SHELLBEACH then
                    is_in_enlightenment_area = true
                    print("[PonoEnergy] In enlightenment area: Moon island terrain!")
                end
                
                -- 月亮沼泽或裂隙地块
                -- 这些通常通过特殊的turf标记
                if not is_in_enlightenment_area then
                    -- 检查是否在月亮沼泽附近（通过实体检测）
                    local ents = TheSim:FindEntities(x, y, z, 15, {"lunar_rift_portal", "moon_tree", "moon_altar", "moon_device"})
                    if #ents > 0 then
                        is_in_enlightenment_area = true
                        print("[PonoEnergy] In enlightenment area: Near lunar structures!")
                    end
                end
            end
            
            -- 方法3：检查是否在月亮风暴区域内
            if not is_in_enlightenment_area and TheWorld.components.moonstorms then
                -- 检查当前位置是否在月亮风暴节点范围内
                local moonstorm_mgr = TheWorld.components.moonstorms
                if moonstorm_mgr.GetMoonstormAtPoint then
                    local storm = moonstorm_mgr:GetMoonstormAtPoint(x, y, z)
                    if storm then
                        is_in_enlightenment_area = true
                        print("[PonoEnergy] In enlightenment area: Inside moon storm!")
                    end
                end
            end
        end
        
        -- 如果在启蒙区域
        if is_in_enlightenment_area then
            -- 启蒙区域，消耗降低为1/6
            consume_multiplier = consume_multiplier / 6
            -- 启蒙区域下直接返回，不再检查其他加速条件
            return consume_multiplier
        end
        
        -- 快速移动模式额外消耗1.5倍
        if inst:HasTag("pono_speed_mode") then
            consume_multiplier = consume_multiplier * 1.5
        end
        
        -- 理智低于一半时消耗+1倍
        if inst.components.sanity then
            local sanity_current = inst.components.sanity.current or 0
            local sanity_max = inst.components.sanity.max or 1
            if sanity_current < (sanity_max * 0.5) then
                consume_multiplier = consume_multiplier + 1
            end
        end
        
        -- 生命值低于一半时消耗+1倍
        if inst.components.health then
            local health_current = inst.components.health.currenthealth or 0
            local health_max = inst.components.health.maxhealth or 1
            if health_current < (health_max * 0.5) then
                consume_multiplier = consume_multiplier + 1
            end
        end
        
        -- 潮湿度高于50时消耗+1倍
        if inst.components.moisture then
            local moisture_current = inst.components.moisture.moisture or 0
            if moisture_current > 50 then  -- 超过50即为高于一半
                consume_multiplier = consume_multiplier + 1
            end
        end
        
        return consume_multiplier
    end

    -- 【新功能】管理移速的通用函数
    local function UpdateSpeed(inst, energy_state, was_high_energy_groggy)
        if not inst.components.locomotor then
            return
        end
        
        -- 【关键修复】在睡眠状态下不更新速度，避免干扰醒来动画
        -- 检查 StateGraph 是否有 sleeping 标签
        if inst.sg and inst.sg:HasStateTag("sleeping") then
            print("[PonoSpeed] Skipping speed update during sleep state")
            return
        end
        
        local is_speed_mode = inst:HasTag("pono_speed_mode")
        
        -- 检查是否从昏迷组件添加的groggy
        local is_groggy_from_knockout = inst.components.mod_pono_grogginess and 
                                       inst.components.mod_pono_grogginess.grogginess_removal_task ~= nil
        
        -- 【修复】先清除我们的速度修改器（但不要清除grogginess的）
        inst.components.locomotor:RemoveExternalSpeedMultiplier(inst, speed_multiplier_key)
        inst.components.locomotor:RemoveExternalSpeedMultiplier(inst, speed_penalty_key)
        inst.components.locomotor:RemoveExternalSpeedMultiplier(inst, speed_mode_key)
        
        -- 只有在不是从昏迷组件添加时才清除groggy速度修改
        if not is_groggy_from_knockout then
            inst.components.locomotor:RemoveExternalSpeedMultiplier(inst, groggy_speed_key)
        end
        
        -- 【关键修复】确保非昏迷状态下不会有 sleeping 标签阻止交互
        if not is_groggy_from_knockout and inst:HasTag("sleeping") then
            print("[PonoNightDebug] WARNING: Removing unexpected sleeping tag not from knockout")
            inst:RemoveTag("sleeping")
        end
        
        -- 应用新的速度修改器（按优先级）
        if is_speed_mode then
            -- 快速移动模式：优先级最高，+75%移速
            inst.components.locomotor:SetExternalSpeedMultiplier(inst, speed_mode_key, SPEED_MODE_MULT)
        elseif energy_state == "boost" and not is_groggy_from_knockout then
            -- 正常增益模式：+10%移速（但不与grogginess叠加）
            inst.components.locomotor:SetExternalSpeedMultiplier(inst, speed_multiplier_key, SPEED_MULT)
        elseif energy_state == "penalty" and not is_groggy_from_knockout then
            -- 惩罚模式：-5%移速（但不与grogginess叠加）
            inst.components.locomotor:SetExternalSpeedMultiplier(inst, speed_penalty_key, SPEED_PENALTY)
        elseif energy_state == "groggy" and not is_groggy_from_knockout then
            -- 高能量催眠模式：-50%移速（只有当不是昏迷造成的groggy时）
            inst.components.locomotor:SetExternalSpeedMultiplier(inst, groggy_speed_key, GROGGY_SPEED)
        end
        
        -- 如果是正常状态且没有特殊条件，则使用基础移速（不设置任何修改器）
    end

    local function UpdateWorkEfficiency(inst)
        local energy_comp = inst.components.mod_pono_energy
        if not energy_comp then 
            return 
        end
        
        local val = energy_comp:GetVal() or 0
        
        -- 判断应该处于哪种状态
        local should_have_boost = (val >= 25 and val <= 175)  -- 加成区间
        local should_have_penalty = (val >= 0 and val < 25)   -- 惩罚区间
        local should_be_groggy = (val > 175)                  -- 催眠区间
        local current_has_boost = inst._pono_has_work_boost or false
        
        -- 记录上一次是否处于高能量催眠状态
        local was_high_energy_groggy = inst._pono_was_high_energy_groggy or false
        inst._pono_was_high_energy_groggy = should_be_groggy
        
        -- 【新功能】检查是否处于快速移动模式
        local is_speed_mode = inst:HasTag("pono_speed_mode")
        
        -- 【新功能】自动退出加速模式：如果处于加速状态但能量不在25-175范围内
        if is_speed_mode and (val < 25 or val > 175) then
            inst:RemoveTag("pono_speed_mode")
            is_speed_mode = false  -- 更新本地变量
            
            -- 播放退出音效
            if inst.SoundEmitter then
                inst.SoundEmitter:PlaySound("dontstarve/characters/wortox/soul/soul_dissipate")
            end
            
            -- 显示提示文字
            if inst.components.talker then
                if val < 25 then
                    inst.components.talker:Say("太累了喵...")
                elseif val > 175 then
                    inst.components.talker:Say("没力气喵...")
                end
            end
        end
        
        -- 【新功能】使用 atk_speed_from_alt 模块管理攻击速度
        -- 攻击速度加成：能量在25-175时提高50%（即 +0.5 的加算修饰符）
        local attack_speed_key = "mod_pono_energy_attack_speed"
        
        if inst.Modifier_common_atkspeedmodifier and inst.RemoveModifier_common_atkspeedmodifier then
            if is_speed_mode then
                -- 快速移动模式下移除攻击速度加成
                inst:RemoveModifier_common_atkspeedmodifier(inst, attack_speed_key)
                print("[PonoAttackSpeed] Removed attack speed boost in speed mode")
            elseif should_have_boost then
                -- 能量在范围内，应用+50%攻击速度（+0.5 加算修饰符）
                inst:Modifier_common_atkspeedmodifier(inst, 0.5, attack_speed_key)
                print("[PonoAttackSpeed] Applied +50% attack speed boost, energy=", val)
            else
                -- 能量不在范围内，移除攻击速度加成
                inst:RemoveModifier_common_atkspeedmodifier(inst, attack_speed_key)
                print("[PonoAttackSpeed] Removed attack speed boost, energy=", val)
            end
        else
            print("[PonoAttackSpeed] Warning: atk_speed_from_alt functions not available")
        end
        
        if should_have_boost then
            -- 取消打哈欠任务（如果有）
            if inst._pono_yawn_task then
                inst._pono_yawn_task:Cancel()
                inst._pono_yawn_task = nil
            end
            
            -- 工作效率加成（由于changeactionsg.lua已处理快速模式限制，这里直接应用加成）
            if inst.components.workmultiplier then
                inst.components.workmultiplier:AddMultiplier(ACTIONS.CHOP, CHOP_MULT, work_multiplier_key)
                inst.components.workmultiplier:AddMultiplier(ACTIONS.MINE, MINE_MULT, work_multiplier_key)
                inst.components.workmultiplier:AddMultiplier(ACTIONS.PICK, PICK_MULT, work_multiplier_key)
                inst.components.workmultiplier:AddMultiplier(ACTIONS.DIG, DIG_MULT, work_multiplier_key)
            end
            
            -- 【关键修复】只在从高能量催眠状态（>175）降低到boost区间时才移除groggy标签
            -- 检查是否是从昏迷组件添加的groggy（通过检查grogginess_removal_task是否存在）
            local is_groggy_from_knockout = inst.components.mod_pono_grogginess and 
                                           inst.components.mod_pono_grogginess.grogginess_removal_task ~= nil
            
            -- 只在从高能量催眠状态转换到boost状态时才清除groggy
            if inst:HasTag("groggy") and was_high_energy_groggy and not is_groggy_from_knockout then
                inst:RemoveTag("groggy")
            end
            
            -- 使用新的移速管理函数
            UpdateSpeed(inst, "boost", was_high_energy_groggy)
            
            inst._pono_has_work_boost = true
            
        elseif should_have_penalty then
            -- 移除加成（如果有）
            if inst.components.workmultiplier then
                inst.components.workmultiplier:RemoveMultiplier(ACTIONS.CHOP, work_multiplier_key)
                inst.components.workmultiplier:RemoveMultiplier(ACTIONS.MINE, work_multiplier_key)
                inst.components.workmultiplier:RemoveMultiplier(ACTIONS.PICK, work_multiplier_key)
                inst.components.workmultiplier:RemoveMultiplier(ACTIONS.DIG, work_multiplier_key)
            end
            
            -- 【关键修复】移除催眠状态（如果有）- 但不移除由grogginess组件添加的标签
            -- 检查是否从昏迷组件添加的groggy（通过检查grogginess_removal_task是否存在）
            local is_groggy_from_knockout = inst.components.mod_pono_grogginess and 
                                           inst.components.mod_pono_grogginess.grogginess_removal_task ~= nil
            
            if inst:HasTag("groggy") and not is_groggy_from_knockout then
                inst:RemoveTag("groggy")
            end
            
            -- 使用新的移速管理函数
            UpdateSpeed(inst, "penalty", was_high_energy_groggy)
            
            -- 启动打哈欠动画定时任务（每10~15秒播放一次）
            if not inst._pono_yawn_task then
                local function PlayYawnAnimation()
                    -- 检查角色是否在潜水状态
                    if inst:HasTag("pono_is_diving") then
                        -- 如果在潜水，不打哈欠，但继续安排下次检查
                        if inst._pono_yawn_task then
                            inst._pono_yawn_task:Cancel()
                        end
                        local next_yawn_time = 10 + math.random() * 5  -- 10~15秒
                        inst._pono_yawn_task = inst:DoTaskInTime(next_yawn_time, PlayYawnAnimation)
                        return
                    end
                    
                    if inst and inst.sg and not inst.sg:HasStateTag("busy") and not inst.sg:HasStateTag("sleeping") then
                        -- 检查是否有 yawn 动画状态
                        if inst.sg.sg.states.yawn then
                            inst.sg:GoToState("yawn")
                        else
                            -- 如果没有 yawn 状态，尝试使用 emote
                            if inst.components.emote then
                                inst.components.emote:DoEmote("sleepy")
                            end
                        end
                    end
                    
                    -- 安排下次打哈欠（10~15秒后）
                    if inst._pono_yawn_task then
                        inst._pono_yawn_task:Cancel()
                    end
                    local next_yawn_time = 10 + math.random() * 5  -- 10~15秒
                    inst._pono_yawn_task = inst:DoTaskInTime(next_yawn_time, PlayYawnAnimation)
                end
                
                -- 首次执行（10~15秒后）
                local first_yawn_time = 10 + math.random() * 5
                inst._pono_yawn_task = inst:DoTaskInTime(first_yawn_time, PlayYawnAnimation)
            end
            
            inst._pono_has_work_boost = false
            
        elseif should_be_groggy then
            -- 取消打哈欠任务（如果有）
            if inst._pono_yawn_task then
                inst._pono_yawn_task:Cancel()
                inst._pono_yawn_task = nil
            end
            
            -- 移除所有其他加成/惩罚
            if inst.components.workmultiplier then
                inst.components.workmultiplier:RemoveMultiplier(ACTIONS.CHOP, work_multiplier_key)
                inst.components.workmultiplier:RemoveMultiplier(ACTIONS.MINE, work_multiplier_key)
                inst.components.workmultiplier:RemoveMultiplier(ACTIONS.PICK, work_multiplier_key)
                inst.components.workmultiplier:RemoveMultiplier(ACTIONS.DIG, work_multiplier_key)
            end
            
            -- 添加催眠状态标签
            if not inst:HasTag("groggy") then
                inst:AddTag("groggy")
            end
            
            -- 使用新的移速管理函数
            UpdateSpeed(inst, "groggy", was_high_energy_groggy)
            
            inst._pono_has_work_boost = false
            
        else
            -- 取消打哈欠任务（如果有）
            if inst._pono_yawn_task then
                inst._pono_yawn_task:Cancel()
                inst._pono_yawn_task = nil
            end
            
            -- 移除工作效率加成
            if inst.components.workmultiplier then
                inst.components.workmultiplier:RemoveMultiplier(ACTIONS.CHOP, work_multiplier_key)
                inst.components.workmultiplier:RemoveMultiplier(ACTIONS.MINE, work_multiplier_key)
                inst.components.workmultiplier:RemoveMultiplier(ACTIONS.PICK, work_multiplier_key)
                inst.components.workmultiplier:RemoveMultiplier(ACTIONS.DIG, work_multiplier_key)
            end
            
            -- 移除催眠标签
            if inst:HasTag("groggy") then
                inst:RemoveTag("groggy")
            end
            
            -- 使用新的移速管理函数
            UpdateSpeed(inst, "normal", was_high_energy_groggy)
            
            inst._pono_has_work_boost = false
        end
    end

    -- 监听能量变化事件，实时更新工作效率
    inst:ListenForEvent("mod_pono_energy_val_change", function(inst)
        UpdateWorkEfficiency(inst)
    end)

    -- 【新功能】为按键技能提供更新函数引用
    inst._pono_update_work_efficiency = function()
        UpdateWorkEfficiency(inst)
    end

    -- 玩家重生/复活时强制重新检查
    inst:ListenForEvent("ms_playerreroll", function(inst)
        inst._pono_has_work_boost = nil  -- 强制重新检查
        UpdateWorkEfficiency(inst)
    end)
    
    inst:ListenForEvent("ms_respawnedfromghost", function(inst)
        inst._pono_has_work_boost = nil  -- 强制重新检查
        UpdateWorkEfficiency(inst)
    end)

    -- 【修复】确保初始状态正确：清除可能的错误标签
    inst:RemoveTag("pono_speed_mode")
    
    -- 【调试】添加标签监控，确保快速模式标签不会意外出现
    inst:DoPeriodicTask(5, function()
        if inst:HasTag("pono_speed_mode") then
            local energy = inst.components.mod_pono_energy and inst.components.mod_pono_energy:GetVal() or 0
            if energy < 25 or energy > 175 then
                print("[PonoDebug] WARNING: Speed mode tag found with invalid energy:", energy)
                inst:RemoveTag("pono_speed_mode")
            end
        end
    end)
    

    
    -- 初始化时设置工作效率（多次尝试确保生效）
    inst:DoTaskInTime(0.5, function()
        inst._pono_has_work_boost = nil  -- 强制重新应用
        -- 确保初始状态没有错误的标签
        if not inst.components.mod_pono_energy or inst.components.mod_pono_energy:GetVal() < 25 or inst.components.mod_pono_energy:GetVal() > 175 then
            inst:RemoveTag("pono_speed_mode")
        end
        UpdateWorkEfficiency(inst)
    end)
    
    inst:DoTaskInTime(1, function()
        UpdateWorkEfficiency(inst)
    end)
    
    inst:DoTaskInTime(2, function()
        UpdateWorkEfficiency(inst)
    end)

    -- 每per秒处理：若睡眠则恢复，否则消耗
    local energy_drain_task = inst:DoPeriodicTask(db.per, function(inst)
        local energy_comp = inst.components.mod_pono_energy
        if not energy_comp then return end

        local current_energy = energy_comp:GetVal()
        local is_sleeping = false
        local has_sleeping_tag = (inst.sg and inst.sg.HasStateTag and inst.sg:HasStateTag("sleeping")) or false
        
        -- 【修复】只有在真正的睡眠状态（bedroll、tent等）时才恢复能量
        -- 排除 sleeper 组件的自动睡眠判断（可能在晚上误判）
        if has_sleeping_tag then
            is_sleeping = true
            print("[PonoEnergy] Sleeping detected via StateGraph tag")
        else
            -- 【关键修复】完全禁用 sleeper 组件的自动判断
            -- sleeper 组件在晚上可能会错误地返回 IsAsleep()=true
            -- 只允许通过明确的睡眠状态标签来判定睡眠
            is_sleeping = false
        end

        -- 【关键功能】能量为0时使用自定义grogginess组件强制睡眠
        if current_energy <= 0 and not has_sleeping_tag then
            if inst.components.mod_pono_grogginess then
                local is_knocked_out = inst.components.mod_pono_grogginess:IsKnockedOut()
                
                if not is_knocked_out then
                    inst.components.mod_pono_grogginess:CheckKnockOut()
                end
            end
        end
        


        -- 【新功能】高能量状态回复理智和血量
        if current_energy > 175 then
            -- 回复理智：+2点/秒（如果有理智组件且未满）
            if inst.components.sanity and inst.components.sanity.current < inst.components.sanity.max then
                inst.components.sanity:DoDelta(2, false)
            end
            
            -- 回复血量：+2点/秒（如果有血量组件且未满）
            if inst.components.health and inst.components.health.currenthealth < inst.components.health.maxhealth then
                inst.components.health:DoDelta(2, true, "mod_pono_energy_regen")
            end
        end

        -- 正常的能量恢复/消耗逻辑
        if is_sleeping then
            -- 睡眠时快速恢复能量(每秒+2)
            if current_energy < db.max then
                energy_comp:DoDelta(2)
                print("[PonoEnergy] Sleeping: +2 energy, now:", energy_comp:GetVal())
            end
        else
            -- 不在睡眠时消耗能量（带状态加速）
            -- 【潜水时不消耗能量】检查 pono_energy_freeze 标签
            if current_energy > 0 and not inst:HasTag("pono_energy_freeze") then
                -- 使用通用函数计算能量消耗加速倍数
                local consume_multiplier = GetEnergyConsumeMultiplier(inst)
                
                -- 应用加速后的消耗
                local final_consume = db.consume * consume_multiplier
                energy_comp:DoDelta(-final_consume)
                
                -- 【调试】打印能量消耗信息
                if consume_multiplier ~= 1 then
                    print("[PonoEnergy] Consume rate:", final_consume, "multiplier:", consume_multiplier, "energy:", energy_comp:GetVal())
                end
            end
        end
    end)

    -- 监听工作动作额外消耗能量（同样受状态加速影响）
    inst:ListenForEvent("startwork", function(inst, data)
        local energy_comp = inst.components.mod_pono_energy
        if not energy_comp then return end

        -- 【潜水时不消耗能量】检查 pono_energy_freeze 标签
        if inst:HasTag("pono_energy_freeze") then
            return
        end

        -- 工作时额外消耗能量（计算状态加速）
        if energy_comp:GetVal() > 0 then
            -- 使用通用函数计算能量消耗加速倍数
            local consume_multiplier = GetEnergyConsumeMultiplier(inst)
            
            -- 应用加速后的工作消耗
            local final_consume = db.consume * consume_multiplier
            energy_comp:DoDelta(-final_consume)
        end
    end)

    -- 【新功能】监听受到攻击事件，处理暗影生物攻击的特殊效果
    inst:ListenForEvent("attacked", function(inst, data)
        local energy_comp = inst.components.mod_pono_energy
        if not energy_comp or not data or not data.attacker then 
            return 
        end

        local attacker = data.attacker
        local damage = data.damage or 0

        -- 检查攻击者是否为暗影生物
        local is_shadow_creature = false
        
        -- 检查常见的暗影生物标签和prefab名称
        if attacker:HasTag("shadowcreature") or 
           attacker:HasTag("shadow") or
           attacker:HasTag("nightmare") then
            is_shadow_creature = true
        end
        
        -- 检查特定的暗影生物prefab名称
        local shadow_prefabs = {
            "crawlinghorror",      -- 爬行梦魇
            "terrorbeak",          -- 恐惧之喙
            "shadowwaxwell",       -- 暗影麦斯威尔
            "bishop_nightmare",    -- 暗影主教
            "rook_nightmare",      -- 暗影战车
            "knight_nightmare",    -- 暗影骑士
            "nightmarebeak",       -- 梦魇之喙
            "crawlingnightmare",   -- 爬行梦魇
            "shadowthrall_hands",  -- 暗影仆从（手）
            "shadowthrall_horns",  -- 暗影仆从（角）
            "shadowthrall_wings"   -- 暗影仆从（翅膀）
        }
        
        if attacker.prefab then
            for _, prefab in ipairs(shadow_prefabs) do
                if attacker.prefab == prefab then
                    is_shadow_creature = true
                    break
                end
            end
        end

        -- 如果是暗影生物攻击，执行特殊效果
        if is_shadow_creature then
            -- 扣除10点能量值
            if energy_comp:GetVal() > 0 then
                energy_comp:DoDelta(-10)
            end
            
            -- 扣除与伤害等量的理智值
            if inst.components.sanity and damage > 0 then
                inst.components.sanity:DoDelta(-damage, false)
            end
        end
    end)
    
    -- 【新功能】攻击速度加成已集成到 UpdateWorkEfficiency 函数中，使用 atk_speed_from_alt 模块实现

    -- 【新功能】快速模式下的通用动作拦截系统
    -- Hook PushBufferedAction 来拦截所有交互动作
    local function SetupSpeedModeInteractionBlock(inst)
        -- 保存原始的 PushBufferedAction 函数
        local old_PushBufferedAction = inst.PushBufferedAction
        if old_PushBufferedAction then
            inst.PushBufferedAction = function(self, buffered_action)
                -- 检查是否处于快速模式
                if inst:HasTag("pono_speed_mode") and buffered_action then
                    local action = buffered_action.action
                    if action then
                        local action_id = action.id
                        
                        -- 【特殊处理】睡眠动作：先清除加速模式，然后允许执行
                        if action_id == "SLEEPIN" then
                            print("[PonoSpeed] Clearing speed mode before entering sleep")
                            inst:RemoveTag("pono_speed_mode")
                            if inst.components.locomotor then
                                inst.components.locomotor:RemoveExternalSpeedMultiplier(inst, speed_mode_key)
                            end
                            -- 允许睡眠动作继续执行
                            return old_PushBufferedAction(self, buffered_action)
                        end
                        
                        -- 定义在快速模式下需要拦截的动作（排除移动、装备、检查）
                        -- 阻止的操作类型（包括检查和对话）
                        local blocked_actions = {
                            "LOOKAT", "TALK", "TALKTO", "ACTIVATE", "FEED", "READ", "CASTSPELL",
                            "COOK", "LOAD", "UNLOAD", "CURE", "OPEN", "CLOSE", 
                            "LOCK", "UNLOCK", "STORE", "TRADE", "TURNON", 
                            "TURNOFF", "TERRAFORM", "PLANTSOIL", "PLANT", "FERTILIZE",
                            "SMOTHER", "MANUALEXTINGUISH", "HAMMER", "ROTATE", "DEPLOY",
                            "CHECKTRAP", "RUMMAGE", "BAIT", "OCEAN_FISHING_POND", "FISH_OCEAN",
                            "NET", "OCEAN_TRAWL", "OCEAN_FISHING_CAST", "SAILING_TURN_WHEEL",
                            "JUMPIN", "TELEPORT_WORM",  -- 虫洞相关动作
                            -- 建筑交互动作（SLEEPIN 已特殊处理，允许执行但先清除加速模式）
                            "SITON", "MOUNT", "DISMOUNT", "ENTER_GYM", "LEAVE_GYM",
                            "CONSTRUCT", "REPAIR", "UPGRADE", "HARVEST", "RESEARCH",
                            "INTERACT_WITH", "USEITEMON", "USEITEM"
                        }
                        
                        -- 检查是否需要拦截
                        local should_block = false
                        for _, blocked_action in ipairs(blocked_actions) do
                            if action_id == blocked_action then
                                should_block = true
                                break
                            end
                        end
                        
                        if should_block then
                            -- 播放台词
                            if inst.components.talker then
                                local blocked_phrases = {
                                    "太快了喵！",  "跑太快停不下来喵！",
                                }
                                local phrase = blocked_phrases[math.random(#blocked_phrases)]
                                inst.components.talker:Say(phrase)
                            end
                            
                            -- 播放错误音效
                            if inst.SoundEmitter then
                                inst.SoundEmitter:PlaySound("dontstarve/common/destroy_wood")
                            end
                            
                            -- 不执行原动作，直接返回
                            return
                        end
                    end
                end
                
                -- 不在快速模式或不需要拦截，正常执行
                return old_PushBufferedAction(self, buffered_action)
            end
        end
    end
    
    -- 应用动作拦截系统
    SetupSpeedModeInteractionBlock(inst)
    
    -- 【夜间对话修复】Hook sleeper组件的自动睡眠判断，只防止夜间误判，不影响帐篷使用
    if inst.components.sleeper then
        local old_IsAsleep = inst.components.sleeper.IsAsleep
        local old_WakeUp = inst.components.sleeper.WakeUp
        
        inst.components.sleeper.IsAsleep = function(self)
            -- 检查是否是真正的昏迷状态（能量为0的强制睡眠）
            local is_knocked_out = inst.components.mod_pono_grogginess and inst.components.mod_pono_grogginess:IsKnockedOut()
            if is_knocked_out then
                return old_IsAsleep and old_IsAsleep(self) or false
            end
            
            -- 检查是否有真正的睡眠目标（帐篷等）
            if inst.sg and inst.sg.statemem and inst.sg.statemem.target then
                -- 有睡眠目标，调用原始方法
                return old_IsAsleep and old_IsAsleep(self) or false
            end
            
            -- 其他情况（如夜间误判）返回false
            return false
        end
        
        -- 【修复】Hook WakeUp 方法，确保正确的醒来流程
        -- 注意：不在这里清除加速模式！因为：
        -- 1. 进入帐篷时已经在 SLEEPIN 动作中清除了加速模式
        -- 2. 如果在这里清除，会在醒来动画播放前就清除，导致动画异常
        inst.components.sleeper.WakeUp = function(self)
            -- 检查是否是 grogginess 组件的昏迷
            local is_grogginess_knockout = inst.components.mod_pono_grogginess and 
                                          inst.components.mod_pono_grogginess:IsKnockedOut()
            
            -- 如果是 grogginess 昏迷，不调用原始 WakeUp，让 grogginess 自己处理
            if not is_grogginess_knockout then
                -- 调用原始的WakeUp方法，确保正常的醒来流程（帐篷等）
                if old_WakeUp then
                    old_WakeUp(self)
                end
            end
        end
    end

    -- 清理任务（在inst移除时）
    inst:ListenForEvent("onremove", function(inst)
        if energy_drain_task then energy_drain_task:Cancel() end
        -- 清理移速加成
        if inst.components.locomotor then
            inst.components.locomotor:RemoveExternalSpeedMultiplier(inst, speed_multiplier_key)
        end
    end)
end)
